package com.kalvan.core.utils;

import org.apache.commons.lang3.StringUtils;

import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.text.FieldPosition;

/**
 * 金额工具类
 *
 * @author chenliang
 */
public class AmountUtil {

    private static final int SCALE = 2;

    /**
     * 字符串转换为金额
     *
     * @param value
     * @return
     * @see
     */
    public static Double parseDouble(String value) {
        if (StringUtils.isBlank(value)) {
            return 0.0d;
        }
        return Double.valueOf(value);
    }

    /**
     * 将字符串"元"转换成"分"
     *
     * @param str
     * @return
     */
    public static String convertDollar2Cent(String str) {
        DecimalFormat df = new DecimalFormat("0.00");
        StringBuffer sb = df.format(Double.parseDouble(str), new StringBuffer(), new FieldPosition(0));
        int idx = sb.toString().indexOf(".");
        sb.deleteCharAt(idx);
        for (; sb.length() != 1; ) {
            if (sb.charAt(0) == '0') {
                sb.deleteCharAt(0);
            } else {
                break;
            }
        }
        return sb.toString();
    }

    /**
     * 将字符串"分"转换成"元"（长格式），如：100分被转换为1.00元。
     *
     * @param s
     * @return
     */
    public static String convertCent2Dollar(String s) {
        if ("".equals(s) || s == null) {
            return "";
        }
        long l;
        if (s.length() != 0) {
            if (s.charAt(0) == '+') {
                s = s.substring(1);
            }
            l = Long.parseLong(s);
        } else {
            return "";
        }
        boolean negative = false;
        if (l < 0) {
            negative = true;
            l = Math.abs(l);
        }
        s = Long.toString(l);
        if (s.length() == 1) {
            return (negative ? ("-0.0" + s) : ("0.0" + s));
        }
        if (s.length() == 2) {
            return (negative ? ("-0." + s) : ("0." + s));
        } else {
            return (negative ? ("-" + s.substring(0, s.length() - 2) + "." + s.substring(s.length() - 2))
                    : (s.substring(0, s.length() - 2) + "." + s.substring(s.length() - 2)));
        }
    }

    /**
     * 将字符串"分"转换成"元"（短格式），如：100分被转换为1元。
     *
     * @param s
     * @return
     */
    public static String convertCent2DollarShort(String s) {
        String ss = convertCent2Dollar(s);
        ss = "" + Double.parseDouble(ss);
        if (ss.endsWith(".0")) {
            return ss.substring(0, ss.length() - 2);
        }
        if (ss.endsWith(".00")) {
            return ss.substring(0, ss.length() - 3);
        } else {
            return ss;
        }
    }

    public static String getYuanString(double amount) {
        BigDecimal bd = new BigDecimal(amount);
        return getYuanString(bd);
    }

    /**
     * 得到金额元字符串
     *
     * @param d
     * @return
     */
    public static String getYuanString(BigDecimal amount) {
        return amount.setScale(2, BigDecimal.ROUND_HALF_EVEN).toString();
    }

    /**
     * 加法
     */
    public static Double add(Double d1, Double d2) {
        return new Double(format(d1.doubleValue() + d2.doubleValue()));
    }

    /**
     * 1、减法<br>
     * 2、…<br>
     *
     * @param d1
     * @param d2
     * @return
     * @see
     */
    public static Double subtract(Double d1, Double d2) {
        return new Double(format(d1.doubleValue() - d2.doubleValue()));
    }

    /**
     * 1、乘法<br>
     * 2、…<br>
     *
     * @param d1
     * @param d2
     * @return
     * @see
     */
    public static BigDecimal multiply(double d1, double d2) {
        String s1 = String.valueOf(d1);
        String s2 = String.valueOf(d2);
        BigDecimal b1 = new BigDecimal(s1);
        BigDecimal b2 = new BigDecimal(s2);
        BigDecimal bb = b1.multiply(b2);
        return bb;
    }

    /**
     * 1、除法<br>
     * 2、scale默认是2<br>
     *
     * @param d1
     * @param d2
     * @return
     * @see
     */
    public static BigDecimal divide(Double d1, Double d2) {
        String s1 = String.valueOf(d1);
        String s2 = String.valueOf(d2);
        BigDecimal b1 = new BigDecimal(s1);
        BigDecimal b2 = new BigDecimal(s2);

        BigDecimal bb = b1.divide(b2, 2, 4);
        return bb;
    }

    /**
     * 精确到小数点后两位，使用四舍五入
     */
    public static double format(double value) {
        return (new BigDecimal(Double.toString(value))).setScale(2, 4).doubleValue();
    }

    /**
     * 比较两个double类型数值是否相等
     */
    public static boolean equals(Double d1, Double d2) {
        if (d1 == null || d2 == null) {
            return false;
        }
        return Math.abs(d1.doubleValue() - d2.doubleValue()) < 0.0001D;
    }

    /**
     * 金额由分转换成元
     */
    public static Double converterAmtToYUAN(String amt) {
        return Double.parseDouble(amt) / 100.0;
    }

    /**
     * 金额由元转换成分
     */
    public static Double converterAmtToMinute(double amt) {
        return amt * 100.0;
    }

    /**
     * 金额由元转换成分,类型为String
     */
    public static String converterAmtToMinuteStr(double amt) {
        String StrAmt = Double.toString(amt * 100.0);
        int index = StrAmt.indexOf('.');
        return StrAmt.substring(0, index);
    }

    /**
     * 比较.
     *
     * @param d1
     * @param d2
     * @return
     */
    public static int compare(double d1, double d2) {
        return new BigDecimal(Double.toString(d1)).setScale(SCALE, BigDecimal.ROUND_HALF_UP)
                .compareTo(new BigDecimal(Double.toString(d2)).setScale(SCALE, BigDecimal.ROUND_HALF_UP));
    }

    /**
     * 大于.
     *
     * @param d1
     * @param d2
     * @return
     */
    public static boolean gt(double d1, double d2) {
        return compare(d1, d2) > 0;
    }

    /**
     * 大于0
     *
     * @param d1
     * @return
     * @see
     */
    public static boolean isgtZero(Double d1) {
        if (d1 == null)
            return false;
        return (compare(d1.doubleValue(), 0.0001D) > 0);
    }

    /**
     * 等于.
     *
     * @param d1
     * @param d2
     * @return
     */
    public static boolean et(double d1, double d2) {
        return compare(d1, d2) == 0;
    }

    /**
     * 不等于.
     *
     * @param d1
     * @param d2
     * @return
     */
    public static boolean ne(double d1, double d2) {
        return compare(d1, d2) != 0;
    }

    /**
     * 小于.
     *
     * @param d1
     * @param d2
     * @return
     */
    public static boolean lt(double d1, double d2) {
        return compare(d1, d2) < 0;
    }

    /**
     * 大于等于.
     *
     * @param d1
     * @param d2
     * @return
     */
    public static boolean ge(double d1, double d2) {
        return compare(d1, d2) >= 0;
    }

    /**
     * 小于等于.
     *
     * @param d1
     * @param d2
     * @return
     */
    public static boolean le(double d1, double d2) {
        return compare(d1, d2) <= 0;
    }

}
